Inbuilt Data Structures¶
Data Structures in a language determine the level of flexibility of using the language. If a Language has efficient, inbuilt data structures then the effort of the programmer is reduced. He does not have to code everything from the scratch. Furthermore, if it has user friendly syntax, it also makes the code more readable.
Python accounts for both readability and efficiency. It provides many
inbuilt data structure classes that are suitable for day to day
programming. In next 4 chapters, we will look at the details of
list
s,tuple
s,set
s and dictionary
s.
First, let’s look at *Zen* of Python - Python Design Principles
In [1]:
import this
The Zen of Python, by Tim Peters
Beautiful is better than ugly.
Explicit is better than implicit.
Simple is better than complex.
Complex is better than complicated.
Flat is better than nested.
Sparse is better than dense.
Readability counts.
Special cases aren't special enough to break the rules.
Although practicality beats purity.
Errors should never pass silently.
Unless explicitly silenced.
In the face of ambiguity, refuse the temptation to guess.
There should be one-- and preferably only one --obvious way to do it.
Although that way may not be obvious at first unless you're Dutch.
Now is better than never.
Although never is often better than *right* now.
If the implementation is hard to explain, it's a bad idea.
If the implementation is easy to explain, it may be a good idea.
Namespaces are one honking great idea -- let's do more of those!
Python is designed according to this philosophy. Now we shall examine basic data structures which comes handy in our journey of Python.
Lists¶
List is a mutable collection of elements(may be of same or different
types), which is indexed by a 0-based integer. Lists are so much like
C
arrays. But the capability of Python lists called Slicing makes
them more powerful.
Creating Lists¶
Creating an empty list
x = [] # [] denotes a list type # or x = list()
Creating list with some initial elements
x = [2,3,0,'g']
In [1]:
x = [1,2,4,5]
In [2]:
x
Out[2]:
[1, 2, 4, 5]
Accessing List elements¶
List elements can be accessed by 0-based integer index as in C
. In
addition to this, Negative indexes are also supported. If x
is a
list, x[-1]
gives 1st element from the last, x[-2]
gives second
element from the last and so on…
In [3]:
x[3]
Out[3]:
5
In [4]:
x[-2]
Out[4]:
4
Obtaining Partitions of the List - Slicing¶
One can extract a portion of a list, and modify the value of it. If
x
is a list, it is achieved by a statement in the form of
x[start:stop:step]
It returns elements of x
from index start
to the index stop
(excluding stop
) in the steps of step
. These 3 arguments are not
mandatory. If not specified start
is set to 0
, stop
is set
to length of list and step
is set to 1
In [5]:
x = [1,2,5,6,7,0,3]
In [6]:
x[1:3] # Access from x[1] to x[2]
Out[6]:
[2, 5]
In [7]:
x[2:5:2] # Access from x[2] to x[4] in the steps of 2
Out[7]:
[5, 7]
In [8]:
x[1:3] = [6] # They can modify original list
In [9]:
x # Look at modified list, 6 is replaced twice
Out[9]:
[1, 6, 6, 7, 0, 3]
In [25]:
x[::-1] # Access the array in reverse order
Out[25]:
[3, 0, 7, 6, 6, 1]
In [10]:
x[:] # Returns copy of list x
Out[10]:
[1, 6, 6, 7, 0, 3]
You have observed that slices return a list, which have the reference to original list. Hence modifying slice results the change in original array.
Deleting List elements by index - del
¶
If the position of element to be deleted is known, it can be deleted by
del
statement
To delete the i
th element of list x
,
del x[i]
In [11]:
del x[2]
In [12]:
x
Out[12]:
[1, 6, 7, 0, 3]
Using Operators on List¶
In [13]:
x = [4,3,5,0,1]
y = [2,1,5,4,0]
In [14]:
x + y
Out[14]:
[4, 3, 5, 0, 1, 2, 1, 5, 4, 0]
Note
x + y
returns a new list that contains elements of y
appended to
x
. This has no effect on original lists x
and y
In [15]:
y * 2
Out[15]:
[2, 1, 5, 4, 0, 2, 1, 5, 4, 0]
Operations on List¶
Unlike the Operators, operations performed on list can act directly on lists and may not return anything
Here are some of operations on list. They are member functions of
class list
. If x
is a list,
x.append(elem)
- adds a single element to the end of the list. It does not return the new list, just modifies the original listx
.x.insert(index, elem)
- inserts the element at the given index, shifting elements to the right.x.extend(list2)
- adds the elements inlist2
to the end of the list. Using+
or+=
on a list is similar to usingextend()
.x.index(ele)
- searches for the given element from the start of the list and returns its index. Throws aValueError
if the element does not appear (usein
to check without a ValueError).x.remove(elem)
- searches for the first instance of the given element and removes it (throwsValueError
if not present)x.sort()
- sorts the list in place (does not return it). (Thesorted()
function is preferred.)x.reverse()
- reverses the list in place (does not return it)x.pop(index)
- removes and returns the element at the given index. Returns the rightmost element ifindex
is omitted (roughly the opposite of append()).
In [16]:
x = [0,3,7,2,1]
In [17]:
x.append(9)
x
Out[17]:
[0, 3, 7, 2, 1, 9]
In [18]:
x.insert(4,4)
x
Out[18]:
[0, 3, 7, 2, 4, 1, 9]
In [19]:
x.extend([8,7,6])
x
Out[19]:
[0, 3, 7, 2, 4, 1, 9, 8, 7, 6]
In [20]:
x.remove(6)
x
Out[20]:
[0, 3, 7, 2, 4, 1, 9, 8, 7]
In [21]:
x.sort()
x
Out[21]:
[0, 1, 2, 3, 4, 7, 7, 8, 9]
In [22]:
x.reverse()
x
Out[22]:
[9, 8, 7, 7, 4, 3, 2, 1, 0]
In [23]:
x.pop()
Out[23]:
0
In [24]:
x.pop(0)
Out[24]:
9
In [25]:
x
Out[25]:
[8, 7, 7, 4, 3, 2, 1]
In [26]:
sorted(x)
Out[26]:
[1, 2, 3, 4, 7, 7, 8]
List elements can also be lists, which gives 2-D array like structure
In [27]:
x = [[2,3,4],
[1,2,2],
[2,3,4]]
In [28]:
x[1]
Out[28]:
[1, 2, 2]
In [29]:
x[2][1]
Out[29]:
3
Note
There is no rule that the length of each sublist in a list must be same
Obtaining length of list - len
¶
In [30]:
x = [1,2,3]
len(x)
Out[30]:
3
In [31]:
x = [[2,3,4],2,['a','v']]
In [32]:
len(x)
Out[32]:
3
Membership Operator in
¶
in
operator can be used to check the existance of an element in the
list
In [33]:
x = [1,2,3,0,5,4]
4 in x
Out[33]:
True
In [34]:
10 in x
Out[34]:
False
Converting an iterator to list¶
Using yield
keyword, one can create an iterator. Using list()
,
one can make a list of all values yield
ed by iterator
In [60]:
list(range(10))
Out[60]:
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]